/**
 * Created by PanJiaChen on 16/11/18.
 */

/**
 * 判断两个数组 是否 是相同的 数组值
 * @param {Array} ary1
 * @param {Array} ary2
 * @param {Function | any} sortFn undefined：不排序，Function：用该函数排序，其他值：使用 sort 函数的默认排序规则
 * @returns
 */
export const sameArrayValue = (ary1, ary2, sortFn) => {
  if (sortFn === undefined) {
    return JSON.stringify(ary1) === JSON.stringify(ary2);
  }

  const ary1copy = [...ary1];
  const ary2copy = [...ary2];
  if (typeof sortFn === 'function') {
    ary1copy.sort(sortFn);
    ary2copy.sort(sortFn);
  } else {
    ary1copy.sort();
    ary2copy.sort();
  }

  return JSON.stringify(ary1copy) === JSON.stringify(ary2copy);
};

/**
 * 转换 excel 日期
 * @param {*} numb
 * @param {*} format
 * @returns
 */
export function formatExcelDate(numb, format) {
  const time = new Date((numb - 1) * 24 * 3600000 + 1);
  time.setYear(time.getFullYear() - 70);
  const year = time.getFullYear() + '';
  const month = time.getMonth() + 1 + '';
  const date = time.getDate() + '';
  if (format && format.length === 1) {
    return year + format + month + format + date;
  }
  return year + (month < 10 ? '0' + month : month) + (date < 10 ? '0' + date : date);
}

/**
 * 将扁平的列表数据转换成树形数据（递归方式）
 * @param {Array<object>} list 要处理的列表数据
 * @param {String|Number} pid 父 id
 * @returns list 中 对象的 pid 等于 pid 的集合
 */
export function tranListToTreeData(list, pid) {
  var arr = []; // 专门用来存放找到的对象
  // list.forEach(item => {
  for (const item of list) {
    if (item.pid === pid) {
      // item 也有可能有儿砸，去找他的儿子们，item 的儿子们的 pid 等于 item 的 id
      const children = tranListToTreeData(list, item.id);
      // 如果 children 的长度大于0，说明 item 有儿子
      if (children.length > 0) {
        item.children = children; // item 也是引用(复杂)数据类型，往 item 新添加一个 children 属性
      }

      // [ 对象1的内存地址, 对象2的内存地址, 对象3的内存地址 ]
      arr.push(item); // 将找到的子节点 item 加入到数组中
    }
  }
  // });
  return arr;
}

/**
 * 将扁平的列表数据转换成树形数据（_.groupBy）
 * @param {Array<object>} list 要处理的数组
 * @param {String} groupByPropName 分组的属性名，会将该属性值相同的归到一组
 * @param {String | Number} extractGroupId 提取的分组 id
 * @returns {object | Array<object>} 如果没传 extractGroupId，则返回整个分组对象，如果传了，则提取该分组
 * @description 分组对象形如：{ groupId1: [{...}, {...}], groupId2: [{...}, {...}], ... }
 */
export function tranListToTreeDataByGroup(list, groupByPropName, extractGroupId) {
  // 1. 通过 _.groupBy 将 list 中 pid 一样的 归到一组去，会得到一个分组对象，形如：{ pid1: [{}, {}], pid2: [{}, {}], ... }
  // 2. 循环 list，给每一项 添加 children（前提：在 第一步 返回的 分组对象 中能找到 一个 键 等于 这一项的 id，说名就是它的子节点们）
  // 3. 由于 el-tree 树形控件，只用绑定一级节点，所以，只要 到 分组对象 中，找出一级部门的数组 绑定给 el-tree 即可
  const groupObj = _.groupBy(list, groupByPropName);
  for (const v of list) {
    const children = groupObj[v.id];
    if (!!children) v.children = children;
  }
  if (extractGroupId === undefined) {
    return groupObj;
  }
  return groupObj[extractGroupId];
}

/**
 * Parse the time to string
 * @param {(Object|string|number)} time
 * @param {string} cFormat
 * @returns {string | null}
 */
export function parseTime(time, cFormat) {
  if (arguments.length === 0 || !time) {
    return null;
  }
  const format = cFormat || '{y}-{m}-{d} {h}:{i}:{s}';
  let date;
  if (typeof time === 'object') {
    date = time;
  } else {
    if (typeof time === 'string') {
      if (/^[0-9]+$/.test(time)) {
        // support "1548221490638"
        time = parseInt(time);
      } else {
        // support safari
        // https://stackoverflow.com/questions/4310953/invalid-date-in-safari
        time = time.replace(new RegExp(/-/gm), '/');
      }
    }

    if (typeof time === 'number' && time.toString().length === 10) {
      time = time * 1000;
    }
    date = new Date(time);
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay(),
  };
  const time_str = format.replace(/{([ymdhisa])+}/g, (result, key) => {
    const value = formatObj[key];
    // Note: getDay() returns 0 on Sunday
    if (key === 'a') {
      return ['日', '一', '二', '三', '四', '五', '六'][value];
    }
    return value.toString().padStart(2, '0');
  });
  return time_str;
}

/**
 * @param {number} time
 * @param {string} option
 * @returns {string}
 */
export function formatTime(time, option) {
  if (('' + time).length === 10) {
    time = parseInt(time) * 1000;
  } else {
    time = +time;
  }
  const d = new Date(time);
  const now = Date.now();

  const diff = (now - d) / 1000;

  if (diff < 30) {
    return '刚刚';
  } else if (diff < 3600) {
    // less 1 hour
    return Math.ceil(diff / 60) + '分钟前';
  } else if (diff < 3600 * 24) {
    return Math.ceil(diff / 3600) + '小时前';
  } else if (diff < 3600 * 24 * 2) {
    return '1天前';
  }
  if (option) {
    return parseTime(time, option);
  } else {
    return d.getMonth() + 1 + '月' + d.getDate() + '日' + d.getHours() + '时' + d.getMinutes() + '分';
  }
}

/**
 * @param {string} url
 * @returns {Object}
 */
export function param2Obj(url) {
  const search = decodeURIComponent(url.split('?')[1]).replace(/\+/g, ' ');
  if (!search) {
    return {};
  }
  const obj = {};
  const searchArr = search.split('&');
  searchArr.forEach(v => {
    const index = v.indexOf('=');
    if (index !== -1) {
      const name = v.substring(0, index);
      const val = v.substring(index + 1, v.length);
      obj[name] = val;
    }
  });
  return obj;
}
